require 'sketchup.rb'
require File.join(__FILE__, '../amtf_mixin.rb')
module AMTF
  class AF另存排版
    include AMTF_mixin
    def initialize()
      设置常用对象
      file=@model.path
      # p @model.path
      文件名 = File.basename(file, '.*')
      if !文件名.include? '_排版'
        路径 = File.dirname(file).freeze
        另存文件名=文件名+'_排版'
        另存全名=路径+'/'+另存文件名+'.skp'
        status = @model.save(另存全名)
        设置常用对象
      end

      层s=@model.layers
      拟删除层=[]
      p 层s.size
      层s.each {|e|
        p e
        if e.name=~ /参考|五金|尺寸标注|开向|拉手/
        # if e.name=~ /五金/
          # 层s.remove(e,true)
          拟删除层.push e
        end
      }
      拟删除层.each {|e|
          层s.remove(e,true)
      }

      清除未使用
      删除隐藏组件(@model)
      清除未使用

      @组件定义名_实例对象h=Hash[]
      @实例对象h_组件定义名=Hash[]
      @含板字组件路径=Hash[]
      @不含板字组件路径=Hash[]
      @含板字组件=[]
      entities = Sketchup.active_model.entities
      entities.each {|e|
        递归路径=[]
        p "顶层e:"+e.to_s
        递归识别组件(e,递归路径)
      }
      # 断点……………….nil

      含板字组件路径a=[]
      @含板字组件路径.each {|k,v|
        # p "含板字组件::::"+k
        # p "含板字路径::::"+v.to_s
        含板字组件路径a.concat(v)
      }
      含板字组件路径a.uniq!

      definitions = @model.definitions

      不含板字组件路径a=[]
      @不含板字组件路径.each {|k,v|
        p "不含板字末级组件::::"+k
        p "不含板字组件路径::::"+v.to_s
        不含板字组件路径a.concat(v)
      }
      不含板字组件路径a.uniq!
      断点……………….nil

      差集=不含板字组件路径a - 含板字组件路径a
      差集.each {|n|
        # e=definitions[n]
        p "删除差集:"+n
        实例对象=@组件定义名_实例对象h[n]
        begin
          实例对象.erase!
        rescue Exception => e
          p e
        end
      }
      断点……………….nil

      清除未使用

      含板字组件路径a.reverse_each {|n|
        # e=definitions[n]
        实例对象=@组件定义名_实例对象h[n]
        begin
          p "炸开:"+n
          实例对象.explode
        rescue Exception => e
          p e
        end
      }
      # 实例对象=@组件定义名_实例对象h["AFU#4"].explode
      # 断点……………….nil
      @层级h=Hash[]
      @含板字组件.each {|e|
        当前层级=0
        炸开所有子组件(e,当前层级)
      }
      断点……………….nil
      # 删除非组件元素

      拟删除元素=[]
      删除多余元素(@model.entities,拟删除元素)
      for d in @model.definitions
        删除多余元素(d.entities,拟删除元素)
      end
      for e in 拟删除元素
        e.erase!
      end
      断点.nil
      # 设置常用对象
      炸开组件
    end

    def 炸开组件
      @遍历完成=false
      @entities=@model.active_entities
      @entities.each{|e|
        # p e.to_s
        if e.kind_of? Sketchup::ComponentInstance
          # p e.definition.name.to_s
          if !e.definition.name.include? '板'
            e.explode
            if @遍历完成=false
              炸开组件
            end
          end
        end
        @遍历完成=true
      }
    end

    def 递归识别组件(e,递归路径)
      @是末级组件=true
      if e.is_a?( Sketchup::ComponentInstance ||Sketchup::ComponentInstance)
        @是末级组件=false
        @子件含板字=false
        # @是组件=true
        组件定义名=e.definition.name
        # @组件定义名_实例对象h[组件定义名]=e#方便后面调用删除命令
        @实例对象h_组件定义名[e]=组件定义名#方便后面调用删除命令!!!不同组件中可能会包含同一个的末级组件
        p '组件定义名:'+组件定义名
        if 组件定义名.include? '板'
          # 递归路径.push 组件定义名
          # p 递归路径.to_s  #会影响兄弟组件的递归路径变量
          @含板字组件.push e
          @子件含板字=true
          @含板字组件路径[组件定义名]=递归路径.dup
          # puts "含板字路径：\n"+递归路径.to_s
        else
          递归路径.push 组件定义名
          # p 递归路径.to_s
          entities = e.definition.entities
          entities.each {|ee|
            递归识别组件(ee,递归路径.dup)
          }
          #递归已经到底……开始逐层返回↓
          if @子件含板字==false
            if @是末级组件
              @不含板字组件路径[组件定义名]=递归路径.dup
              @是末级组件=false#递归返回是只认最先返回的是末级组件
            end
          end
          #递归已经到底……开始逐层返回↑
        end
      end
    end


    def 删除多余元素(entities,拟删除元素)
      for e in entities.to_a
        if !(e.is_a?( Sketchup::Face ) || e.is_a?( Sketchup::ComponentInstance ) || e.is_a?( Sketchup::Group ))
          if e.is_a?( Sketchup::Edge )
            faces = e.faces
            # p faces.size
            if faces.size<1
                # e.erase!
                拟删除元素.concat(拟删除元素)
            end
          else
            # e.erase!
            拟删除元素.concat(拟删除元素)
          end
        end
      end
    end
  end#class

end # module amtf_su
